
#ifndef RConvert_h
#define RConvert_h

#include <System/Object.h>
#include <System/String.h>
#include <System/Array.h>

#include <Defines.h>
#include <Typedef.h>

namespace Riccsson
{
	namespace System
	{
		class IFormatProvider;

		// Summary:
		//     Converts a base data Type* to another base data type.
		class Convert sealed
		{
			// Make this class only static.
			private: Convert(){}

			// Summary:
			//     A constant representing a database column absent of data; that is, database
			//     null.
			//public: static readonly object* DBNull;

			// Summary:
			//     Returns an object* of the specified Type* whose value is equivalent to the
			//     specified object. A parameter supplies culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An object* that implements the System.IConvertible interface.
			//
			//   conversionType:
			//     The Type* of object* to return.
			//
			//   provider:
			//     An object* that supplies culture-specific formatting information.
			//
			// Returns:
			//     An object* whose Type* is conversionType* and whose value is equivalent to value.-or-
			//     value, if the Type* of value and conversionType* are equal.-or- A null reference
			//     (Nothing in Visual Basic), if value is null and conversionType* is not a value
			//     type.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported. -or-value is null, and conversionType* is
			//     a value type.-or-value does not implement the System.IConvertible interface.
			//
			//   System.FormatException:
			//     value is not in a format for conversionType* recognized by provider.
			//
			//   System.OverflowException:
			//     value represents a number that is out of the range of conversionType.
			//
			//   System.ArgumentNullException:
			//     conversionType* is null.
			public: static GC_PTR<object> ChangeType(object* value, Type* conversionType, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Returns an object* of the specified Type* whose value is equivalent to the
			//     specified object. A parameter supplies culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An object* that implements the System.IConvertible interface.
			//
			//   typeCode:
			//     The Type* of object* to return.
			//
			//   provider:
			//     An object* that supplies culture-specific formatting information.
			//
			// Returns:
			//     An object* whose underlying Type* is TypeCode* and whose value is equivalent
			//     to value.-or- A null reference (Nothing in Visual Basic), if value is null
			//     and TypeCode* is System.TypeCode.Empty, System.TypeCode.String, or System.TypeCode.Object.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported. -or-value is null, and TypeCode* specifies
			//     a value type.-or-value does not implement the System.IConvertible interface.
			//
			//   System.FormatException:
			//     value is not in a format for the TypeCode* Type* recognized by provider.
			//
			//   System.OverflowException:
			//     value represents a number that is out of the range of the TypeCode* type.
			//
			//   System.ArgumentException:
			//     TypeCode* is invalid.
			public: static GC_PTR<object> ChangeType(object* value, TypeCode* typeCode, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts a subset of a Unicode character array, which encodes binary data
			//     as base 64 digits, to an equivalent 8-bit unsigned integer array. Parameters
			//     specify the subset in the input array and the number of elements to convert.
			//
			// Parameters:
			//   inArray:
			//     A Unicode character array.
			//
			//   offset:
			//     A position within inArray.
			//
			//   length:
			//     The number of elements in inArray to convert.
			//
			// Returns:
			//     An array of 8-bit unsigned integers equivalent to length elements at position
			//     offset in inArray.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     inArray is null.
			//
			//   System.ArgumentOutOfRangeException:
			//     offset or length is less than 0.-or- offset plus length indicates a position
			//     not within inArray.
			//
			//   System.FormatException:
			//     The length of inArray, ignoring white space characters, is not zero or a
			//     multiple of 4. -or-The format of inArray is invalid. inArray contains a non-base
			//     64 character, more than two padding characters, or a non-white space character
			//     among the padding characters.
			//[SecuritySafeCritical]
			public: static GC_PTR<Array<byte>> FromBase64CharArray(Array<char>* inArray, int offset, int length)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.String, which encodes binary data as base 64
			//     digits, to an equivalent 8-bit unsigned integer array.
			//
			// Parameters:
			//   s:
			//     A System.String.
			//
			// Returns:
			//     An array of 8-bit unsigned integers equivalent to s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     The length of s, ignoring white space characters, is not zero or a multiple
			//     of 4. -or-The format of s is invalid. s contains a non-base 64 character,
			//     more than two padding characters, or a non-white space character among the
			//     padding characters.
			//[SecuritySafeCritical]
			public: static GC_PTR<Array<byte>> FromBase64String(string* s)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the System.TypeCode for the specified object.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			// Returns:
			//     The System.TypeCode for value, or System.TypeCode.Empty if value is null.
			public: static TypeCode* GetTypeCode(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns an indication whether the specified object* is of Type* System.DBNull.
			//
			// Parameters:
			//   value:
			//     An object.
			//
			// Returns:
			//     true if value is of Type* System.DBNull; otherwise, false.
			public: static bool IsDBNull(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts a subset of an 8-bit unsigned integer array to an equivalent subset
			//     of a Unicode character array encoded with base 64 digits. Parameters specify
			//     the subsets as offsets in the input and output arrays, and the number of
			//     elements in the input array to convert.
			//
			// Parameters:
			//   inArray:
			//     An input array of 8-bit unsigned integers.
			//
			//   offsetIn:
			//     A position within inArray.
			//
			//   length:
			//     The number of elements of inArray to convert.
			//
			//   outArray:
			//     An output array of Unicode characters.
			//
			//   offsetOut:
			//     A position within outArray.
			//
			// Returns:
			//     A 32-bit signed integer containing the number of bytes in outArray.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     inArray or outArray is null.
			//
			//   System.ArgumentOutOfRangeException:
			//     offsetIn, offsetOut, or length is negative.-or- offsetIn plus length is greater
			//     than the length of inArray.-or- offsetOut plus the number of elements to
			//     return is greater than the length of outArray.
			public: static int ToBase64CharArray(Array<byte> inArray, int offsetIn, int length, Array<char> outArray, int offsetOut)
			{
				throw;
			}

			//
			// Summary:
			//     Converts an array of 8-bit unsigned integers to its equivalent System.String
			//     representation encoded with base 64 digits.
			//
			// Parameters:
			//   inArray:
			//     An array of 8-bit unsigned integers.
			//
			// Returns:
			//     The System.string* representation, in base 64, of the contents of inArray.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     inArray is null.
			public: static GC_PTR<string> ToBase64String(Array<byte> inArray)
			{
				throw;
			}

			//
			// Summary:
			//     Converts a subset of an array of 8-bit unsigned integers to its equivalent
			//     System.string* representation encoded with base 64 digits. Parameters specify
			//     the subset as an offset in the input array, and the number of elements in
			//     the array to convert.
			//
			// Parameters:
			//   inArray:
			//     An array of 8-bit unsigned integers.
			//
			//   offset:
			//     An offset in inArray.
			//
			//   length:
			//     The number of elements of inArray to convert.
			//
			// Returns:
			//     The System.string* representation in base 64 of length elements of inArray
			//     starting at position offset.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     inArray is null.
			//
			//   System.ArgumentOutOfRangeException:
			//     offset or length is negative.-or- offset plus length is greater than the
			//     length of inArray.
			public: static GC_PTR<string> ToBase64String(Array<byte> inArray, int offset, int length)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified Boolean value; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A Boolean.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static bool ToBoolean(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			public: static bool ToBoolean(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static bool ToBoolean(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			public: static bool ToBoolean(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent Boolean value.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			public: static bool ToBoolean(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent Boolean value.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			public: static bool ToBoolean(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			public: static bool ToBoolean(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			public: static bool ToBoolean(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of a specified System.object* to an equivalent Boolean
			//     value.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     true or false, which reflects the value returned by invoking the System.IConvertible.ToBoolean(System.IFormatProvider*)
			//     method for the underlying Type* of value. If value is null, the method returns
			//     false.
			public: static bool ToBoolean(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			//[CLSCompliant(false)]
			public: static bool ToBoolean(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			public: static bool ToBoolean(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a logical value to
			//     its Boolean equivalent.
			//
			// Parameters:
			//   value:
			//     A System.string* that contains the value of either System.Boolean.TrueString
			//     or System.Boolean.FalseString.
			//
			// Returns:
			//     true if value equals System.Boolean.TrueString, or false if value equals
			//     System.Boolean.Falsestring* or null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not equal to System.Boolean.Truestring* or System.Boolean.FalseString.
			public: static bool ToBoolean(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			//[CLSCompliant(false)]
			public: static bool ToBoolean(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			//[CLSCompliant(false)]
			public: static bool ToBoolean(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to an equivalent
			//     Boolean value.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     true if value is not zero; otherwise, false.
			//[CLSCompliant(false)]
			public: static bool ToBoolean(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an equivalent Boolean
			//     value using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     true or false, which reflects the value returned by invoking the System.IConvertible.ToBoolean(System.IFormatProvider*)
			//     method for the underlying Type* of value. If value is null, the method returns
			//     false.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement the System.IConvertible interface.
			public: static bool ToBoolean(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a logical value to
			//     its Boolean equivalent using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A string* that contains the value of either System.Boolean.Truestring* or System.Boolean.FalseString.
			//
			//   provider:
			//     (Reserved) An System.IFormatProvider* interface implementation that supplies
			//     culture-specific formatting information.
			//
			// Returns:
			//     true if value equals System.Boolean.TrueString, or false if value equals
			//     System.Boolean.Falsestring* or null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not equal to System.Boolean.Truestring* or System.Boolean.FalseString.
			public: static bool ToBoolean(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 8-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			public: static byte ToByte(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 8-bit unsigned integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static byte ToByte(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 8-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 8-bit unsigned integer equivalent to value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Byte.MaxValue.
			public: static byte ToByte(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 8-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Byte.MaxValue or less than System.Byte.MinValue.
			public: static byte ToByte(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 8-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Byte.MaxValue or less than System.Byte.MinValue.
			public: static byte ToByte(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 8-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Byte.MaxValue or less than System.Byte.MinValue.
			public: static byte ToByte(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Byte.MinValue or greater than System.Byte.MaxValue.
			public: static byte ToByte(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Byte.MinValue or greater than System.Byte.MaxValue.
			public: static byte ToByte(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an 8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static byte ToByte(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Byte.MinValue.
			//[CLSCompliant(false)]
			public: static byte ToByte(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Byte.MinValue or greater than System.Byte.MaxValue.
			public: static byte ToByte(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Byte.MinValue or greater than
			//     System.Byte.MaxValue.
			public: static byte ToByte(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Byte.MaxValue.
			//[CLSCompliant(false)]
			public: static byte ToByte(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Byte.MaxValue.
			//[CLSCompliant(false)]
			public: static byte ToByte(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to an equivalent
			//     8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Byte.MaxValue.
			//[CLSCompliant(false)]
			public: static byte ToByte(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an 8-bit unsigned integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			public: static byte ToByte(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     8-bit unsigned integer using specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Byte.MinValue or greater than
			//     System.Byte.MaxValue.
			public: static byte ToByte(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string* representation of a number in a specified base to an
			//     equivalent 8-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     An 8-bit unsigned integer equivalent to the number in value.-or- Zero if
			//     value is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     unsigned number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a base 10 unsigned number, is prefixed with a negative
			//     sign.-or-The return value is less than System.Byte.MinValue or larger than
			//     System.Byte.MaxValue.
			public: static byte ToByte(string* value, int fromBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			public: static char ToChar(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified Unicode character value; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static char ToChar(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static char ToChar(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A double-precision floating-point number.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static char ToChar(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A single-precision floating-point number.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static char ToChar(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Char.MinValue or greater than System.Char.MaxValue.
			public: static char ToChar(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Char.MinValue or greater than System.Char.MaxValue.
			public: static char ToChar(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a Unicode character.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.-or- System.Char.MinValue
			//     if value equals null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement the System.IConvertible interface.
			public: static char ToChar(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Char.MinValue.
			//[CLSCompliant(false)]
			public: static char ToChar(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than System.Char.MinValue.
			public: static char ToChar(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the first character of a System.string* to a Unicode character.
			//
			// Parameters:
			//   value:
			//     A System.string* of length 1 or null.
			//
			// Returns:
			//     The Unicode character equivalent to the first and only character in value.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     value is null.
			//
			//   System.FormatException:
			//     The length of value is not 1.
			public: static char ToChar(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Char.MaxValue.
			//[CLSCompliant(false)]
			public: static char ToChar(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Char.MaxValue.
			//[CLSCompliant(false)]
			public: static char ToChar(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to its equivalent
			//     Unicode character.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static char ToChar(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to its equivalent Unicode
			//     character using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The Unicode character equivalent to the value of value.-or- System.Char.MinValue
			//     if value equals null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement the System.IConvertible interface.
			public: static char ToChar(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the first character of a System.string* to a Unicode character using
			//     specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* of length 1 or null.
			//
			//   provider:
			//     (Reserved) An System.IFormatProvider* interface implementation that supplies
			//     culture-specific formatting information.
			//
			// Returns:
			//     The Unicode character equivalent to the first and only character in value.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     value is null.
			//
			//   System.FormatException:
			//     The length of value is not 1.
			public: static char ToChar(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a System.DateTime.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A System.DateTime equivalent to the value of value.-or- A System.DateTime
			//     equivalent to System.DateTime.MinValue if value is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a valid System.DateTime value.
			//
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.-or-The conversion is not supported.
			public: static GC_PTR<DateTime> ToDateTime(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a date and time to
			//     an equivalent System.DateTime.
			//
			// Parameters:
			//   value:
			//     The string* representation of a date and time.
			//
			// Returns:
			//     A System.DateTime equivalent to the value of value.-or- A System.DateTime
			//     equivalent to System.DateTime.MinValue if value is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a properly formatted date and time string.
			public: static GC_PTR<DateTime> ToDateTime(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a System.DateTime using
			//     the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A System.DateTime equivalent to the value of value.-or- A System.DateTime
			//     equivalent to System.DateTime.MinValue if value is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static GC_PTR<DateTime> ToDateTime(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     System.DateTime using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a date and time to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A System.DateTime equivalent to the value of value.-or- A System.DateTime
			//     equivalent to System.DateTime.MinValue if value is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a properly formatted date and time string.
			public: static GC_PTR<DateTime> ToDateTime(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent System.Decimal
			//     number.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			public: static decimal ToDecimal(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The System.Decimal number equivalent to the value of value.
			public: static decimal ToDecimal(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static decimal ToDecimal(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A System.DateTime.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static decimal ToDecimal(DateTime* value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified System.Decimal number; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static decimal ToDecimal(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     The numeric value of value is greater than System.Decimal.MaxValue or less
			//     than System.Decimal.MinValue.
			public: static decimal ToDecimal(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to the equivalent System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Decimal.MaxValue or less than System.Decimal.MinValue.
			public: static decimal ToDecimal(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.
			public: static decimal ToDecimal(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.
			public: static decimal ToDecimal(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a System.Decimal number.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static decimal ToDecimal(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static decimal ToDecimal(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to an equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.
			public: static decimal ToDecimal(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a number in a valid format.
			//
			//   System.OverflowException:
			//     value represents a number less than System.Decimal.MinValue or greater than
			//     System.Decimal.MaxValue.
			public: static decimal ToDecimal(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static decimal ToDecimal(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static decimal ToDecimal(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     System.Decimal number.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The System.Decimal number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static decimal ToDecimal(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an System.Decimal number
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static decimal ToDecimal(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     System.Decimal number using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A System.Decimal number equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a number in a valid format.
			//
			//   System.OverflowException:
			//     value represents a number less than System.Decimal.MinValue or greater than
			//     System.Decimal.MaxValue.
			public: static decimal ToDecimal(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent double-precision
			//     floating point number.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			public: static double ToDouble(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The double-precision floating point number equivalent to the value of value.
			public: static double ToDouble(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static double ToDouble(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.
			public: static double ToDouble(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified double-precision floating point number; no actual conversion
			//     is performed.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static double ToDouble(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.
			public: static double ToDouble(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.
			public: static double ToDouble(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.
			public: static double ToDouble(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a double-precision floating
			//     point number.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value,
			//     or zero if value is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static double ToDouble(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static double ToDouble(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to an equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.
			public: static double ToDouble(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.-or-
			//     Zero if value is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a number in a valid format.
			//
			//   System.OverflowException:
			//     value represents a number less than System.Double.MinValue or greater than
			//     System.Double.MaxValue.
			public: static double ToDouble(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static double ToDouble(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static double ToDouble(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     double-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The double-precision floating point number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static double ToDouble(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an double-precision
			//     floating point number using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value,
			//     or zero if value is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static double ToDouble(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     double-precision floating point number using the specified culture-specific
			//     formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A double-precision floating point number equivalent to the value of value.-or-
			//     Zero if value is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a number in a valid format.
			//
			//   System.OverflowException:
			//     value represents a number less than System.Double.MinValue or greater than
			//     System.Double.MaxValue.
			public: static double ToDouble(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 16-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			public: static short ToInt16(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The 16-bit signed integer equivalent to the value of value.
			public: static short ToInt16(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 16-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 16-bit signed integer equivalent to value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue.
			public: static short ToInt16(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 16-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue or less than System.Int16.MinValue.
			public: static short ToInt16(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 16-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue or less than System.Int16.MinValue.
			public: static short ToInt16(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 16-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue or less than System.Int16.MinValue.
			public: static short ToInt16(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The 16-bit signed integer equivalent of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue or less than System.Int16.MinValue.
			public: static short ToInt16(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue or less than System.Int16.MinValue.
			public: static short ToInt16(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static short ToInt16(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static short ToInt16(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 16-bit signed integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static short ToInt16(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int16.MinValue or greater than
			//     System.Int16.MaxValue.
			public: static short ToInt16(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue.
			//[CLSCompliant(false)]
			public: static short ToInt16(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue.
			//[CLSCompliant(false)]
			public: static short ToInt16(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The 16-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int16.MaxValue.
			//[CLSCompliant(false)]
			public: static short ToInt16(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 16-bit signed integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static short ToInt16(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     16-bit signed integer using specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int16.MinValue or greater than
			//     System.Int16.MaxValue.
			public: static short ToInt16(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string* representation of a number in a specified base to an
			//     equivalent 16-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     A 16-bit signed integer equivalent to the number in value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     signed number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a non-base 10 signed number, is prefixed with a negative
			//     sign.-or-The return value is less than System.Int16.MinValue or larger than
			//     System.Int16.MaxValue.
			public: static short ToInt16(string* value, int fromBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 32-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			public: static int ToInt32(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The 32-bit signed integer equivalent to the value of value.
			public: static int ToInt32(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 32-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 32-bit signed integer equivalent to value.
			public: static int ToInt32(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 32-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int32.MaxValue or less than System.Int32.MinValue.
			public: static int ToInt32(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 32-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int32.MaxValue or less than System.Int32.MinValue.
			public: static int ToInt32(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 32-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int32.MaxValue or less than System.Int32.MinValue.
			public: static int ToInt32(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 32-bit signed integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static int ToInt32(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int32.MaxValue or less than System.Int32.MinValue.
			public: static int ToInt32(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static int ToInt32(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static int ToInt32(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to an equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value.
			public: static int ToInt32(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int32.MinValue or greater than
			//     System.Int32.MaxValue.
			public: static int ToInt32(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int32.MaxValue.
			//[CLSCompliant(false)]
			public: static int ToInt32(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int32.MaxValue.
			//[CLSCompliant(false)]
			public: static int ToInt32(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The 32-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static int ToInt32(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 32-bit signed integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static int ToInt32(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     32-bit signed integer using specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int32.MinValue or greater than
			//     System.Int32.MaxValue.
			public: static int ToInt32(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the System.string* representation of a number in a specified base
			//     to an equivalent 32-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the number in value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     signed number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a non-base 10 signed number, is prefixed with a negative
			//     sign.-or-The return value is less than System.Int32.MinValue or larger than
			//     System.Int32.MaxValue.
			public: static int ToInt32(string* value, int fromBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 64-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			public: static long ToInt64(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The 64-bit signed integer equivalent to the value of value.
			public: static long ToInt64(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 64-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 64-bit signed integer equivalent to value.
			public: static long ToInt64(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 64-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int64.MaxValue or less than System.Int64.MinValue.
			public: static long ToInt64(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 64-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int64.MaxValue or less than System.Int64.MinValue.
			public: static long ToInt64(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 64-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int64.MaxValue or less than System.Int64.MinValue.
			public: static long ToInt64(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The 64-bit signed integer equivalent to the value of value.
			public: static long ToInt64(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 64-bit signed integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static long ToInt64(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static long ToInt64(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 64-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static long ToInt64(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to an equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value.
			public: static long ToInt64(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int64.MinValue or greater than
			//     System.Int64.MaxValue.
			public: static long ToInt64(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static long ToInt64(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.Int64.MaxValue.
			//[CLSCompliant(false)]
			public: static long ToInt64(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The 64-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static long ToInt64(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 64-bit signed integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static long ToInt64(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     64-bit signed integer using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int64.MinValue or greater than
			//     System.Int64.MaxValue.
			public: static long ToInt64(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string* representation of a number in a specified base to an
			//     equivalent 64-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the number in value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     signed number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a non-base 10 signed number, is prefixed with a negative
			//     sign.-or-The return value is less than System.Int64.MinValue or larger than
			//     System.Int64.MaxValue.
			public: static long ToInt64(string* value, int fromBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 8-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 8-bit
			//     signed integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 8-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 8-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 8-bit signed integer. If value is halfway between
			//     two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an 8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 8-bit signed integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to the equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.SByte.MinValue or greater than
			//     System.SByte.MaxValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue or less than System.SByte.MinValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.SByte.MaxValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an 8-bit signed integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value, or zero if value
			//     is null.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     8-bit signed integer using specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     value is null.
			//
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.SByte.MinValue or greater than
			//     System.SByte.MaxValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string* representation of a number in a specified base to an
			//     equivalent 8-bit signed integer.
			//
			// Parameters:
			//   value:
			//     A string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     An 8-bit signed integer equivalent to the number in value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     signed number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a non-base 10 signed number, is prefixed with a negative
			//     sign.-or-The return value is less than System.SByte.MinValue or larger than
			//     System.SByte.MaxValue.
			//[CLSCompliant(false)]
			public: static sbyte ToSByte(string* value, int fromBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent single-precision
			//     floating point number.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			public: static float ToSingle(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The single-precision floating point number equivalent to the value of value.
			public: static float ToSingle(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Calling this method always throws System.InvalidCastException.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     This conversion is not supported. No value is returned.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     This conversion is not supported.
			public: static float ToSingle(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.value
			//     is rounded using rounding to nearest. For example, when rounded to two decimals,
			//     the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36.
			public: static float ToSingle(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.value
			//     is rounded using rounding to nearest. For example, when rounded to two decimals,
			//     the value 2.345 becomes 2.34 and the value 2.355 becomes 2.36.
			public: static float ToSingle(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified single-precision floating point number; no actual conversion
			//     is performed.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			public: static float ToSingle(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.
			public: static float ToSingle(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.
			public: static float ToSingle(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a single-precision floating
			//     point number.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value,
			//     or zero if value is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static float ToSingle(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 8-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static float ToSingle(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to an equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.
			public: static float ToSingle(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.-or-
			//     Zero if value is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a number in a valid format.
			//
			//   System.OverflowException:
			//     value represents a number less than System.Single.MinValue or greater than
			//     System.Single.MaxValue.
			public: static float ToSingle(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static float ToSingle(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static float ToSingle(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     single-precision floating point number.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The single-precision floating point number equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static float ToSingle(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to an single-precision
			//     floating point number using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value,
			//     or zero if value is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			public: static float ToSingle(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     single-precision floating point number using the specified culture-specific
			//     formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A single-precision floating point number equivalent to the value of value.-or-
			//     Zero if value is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value is not a number in a valid format.
			//
			//   System.OverflowException:
			//     value represents a number less than System.Single.MinValue or greater than
			//     System.Single.MaxValue.
			public: static float ToSingle(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean to its equivalent System.String
			//     representation.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static string* ToString(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to its equivalent System.String
			//     representation.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.DateTime to its equivalent System.String
			//     representation.
			//
			// Parameters:
			//   value:
			//     A System.DateTime.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(DateTime* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to its equivalent System.string* representation.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to its equivalent System.string* representation.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to its System.string* representation.
			//
			// Parameters:
			//   value:
			//     An System.object* or null.
			//
			// Returns:
			//     The System.string* representation of the value of value, or System.String.Empty
			//     if value is null.
			public: static GC_PTR<string> ToString(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean to its equivalent System.String
			//     representation.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			//   provider:
			//     (Reserved) An instance of an System.IFormatProvider* interface implementation.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(bool value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(byte value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of an 8-bit unsigned integer to its equivalent string
			//     representation in a specified base.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			//   toBase:
			//     The base of the return value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     The string* representation of value in base toBase.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     toBase is not 2, 8, 10, or 16.
			public: static GC_PTR<string> ToString(byte value, int toBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to its equivalent System.String
			//     representation.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(char value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.DateTime to its equivalent System.String
			//     representation.
			//
			// Parameters:
			//   value:
			//     A System.DateTime.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(DateTime* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(decimal value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to its equivalent System.string* representation.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.provider is ignored; it
			//     does not participate in this operation.
			public: static GC_PTR<string> ToString(double value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to its equivalent System.string* representation.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(float value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(int value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of a 32-bit signed integer to its equivalent System.String
			//     representation in a specified base.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			//   toBase:
			//     The base of the return value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     The System.string* representation of value in base toBase.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     toBase is not 2, 8, 10, or 16.
			public: static GC_PTR<string> ToString(int value, int toBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(long value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of a 64-bit signed integer to its equivalent System.String
			//     representation in a specified base.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			//   toBase:
			//     The base of the return value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     The System.string* representation of value in base toBase.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     toBase is not 2, 8, 10, or 16.
			public: static GC_PTR<string> ToString(long value, int toBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to its equivalent System.String
			//     representation using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* or null.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* representation of the value of value, or System.String.Empty
			//     if value is null.
			public: static GC_PTR<string> ToString(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(sbyte value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			public: static GC_PTR<string> ToString(short value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of a 16-bit signed integer to its equivalent System.String
			//     representation in a specified base.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			//   toBase:
			//     The base of the return value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     The System.string* representation of value in base toBase.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     toBase is not 2, 8, 10, or 16.
			public: static GC_PTR<string> ToString(short value, int toBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(uint value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(ulong value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to its equivalent
			//     System.string* representation.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     The System.string* equivalent of the value of value.
			//[CLSCompliant(false)]
			public: static GC_PTR<string> ToString(ushort value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 16-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The 16-bit unsigned integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 16-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 16-bit unsigned integer equivalent to value.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 16-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 16-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 16-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The 16-bit unsigned integer equivalent of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 16-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to the equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     The 16-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int16.MinValue or greater than
			//     System.Int16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 16-bit unsigned integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 16-bit unsigned integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     16-bit unsigned integer using specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int16.MinValue or greater than
			//     System.Int16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string* representation of a number in a specified base to an
			//     equivalent 16-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     A 16-bit unsigned integer equivalent to the number in value.-or- Zero if
			//     value is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     unsigned number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a non-base 10 unsigned number, is prefixed with a
			//     negative sign.-or-The return value is less than System.UInt16.MinValue or
			//     larger than System.UInt16.MaxValue.
			//[CLSCompliant(false)]
			public: static ushort ToUInt16(string* value, int fromBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 32-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The 32-bit unsigned integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 32-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 32-bit unsigned integer equivalent to value.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 32-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 32-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 32-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The 32-bit unsigned integer equivalent of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A 32-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A 32-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 8-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to the equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     The 32-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A 32-bit unsigned integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int32.MinValue or greater than
			//     System.Int32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 32-bit unsigned integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit unsigned integer to an equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     A 32-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is greater than System.UInt32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The 32-bit unsigned integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 32-bit unsigned integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 32-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     32-bit unsigned integer using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 32-bit unsigned integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int32.MinValue or greater than
			//     System.Int32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string* representation of a number in a specified base to an
			//     equivalent 32-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     A 32-bit unsigned integer equivalent to the number in value.-or- Zero if
			//     value is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     unsigned number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a non-base 10 unsigned number, is prefixed with a
			//     negative sign.-or-The return value is less than System.UInt32.MinValue or
			//     larger than System.UInt32.MaxValue.
			//[CLSCompliant(false)]
			public: static uint ToUInt32(string* value, int fromBase)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Boolean value to the equivalent 64-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Boolean value.
			//
			// Returns:
			//     The number 1 if value is true; otherwise, 0.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(bool value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit unsigned integer to the equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit unsigned integer.
			//
			// Returns:
			//     The 64-bit signed integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(byte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified Unicode character to the equivalent 64-bit
			//     unsigned integer.
			//
			// Parameters:
			//   value:
			//     A Unicode character.
			//
			// Returns:
			//     The 64-bit unsigned integer equivalent to value.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(char value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.Decimal number to an equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.Decimal number.
			//
			// Returns:
			//     value rounded to the nearest 64-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt64.MaxValue.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(decimal value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified double-precision floating point number
			//     to an equivalent 64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A double-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 64-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt64.MaxValue.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(double value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified single-precision floating point number
			//     to an equivalent 64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A single-precision floating point number.
			//
			// Returns:
			//     value rounded to the nearest 64-bit unsigned integer. If value is halfway
			//     between two whole numbers, the even number is returned; that is, 4.5 is converted
			//     to 4, and 5.5 is converted to 6.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero or greater than System.UInt64.MaxValue.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(float value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit signed integer to an equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit signed integer.
			//
			// Returns:
			//     The 64-bit unsigned integer equivalent of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(int value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 64-bit signed integer to an equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 64-bit signed integer.
			//
			// Returns:
			//     A 64-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(long value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface or null.
			//
			// Returns:
			//     A 64-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			//
			// Exceptions:
			//   System.InvalidCastException:
			//     value does not implement System.IConvertible.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(object* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 8-bit signed integer to the equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     An 8-bit signed integer.
			//
			// Returns:
			//     The 64-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(sbyte value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit signed integer to the equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit signed integer.
			//
			// Returns:
			//     The 64-bit unsigned integer equivalent to the value of value.
			//
			// Exceptions:
			//   System.OverflowException:
			//     value is less than zero.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(short value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			// Returns:
			//     A 64-bit signed integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int64.MinValue or greater than
			//     System.Int64.MaxValue.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(string* value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 32-bit unsigned integer to an equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 32-bit unsigned integer.
			//
			// Returns:
			//     The 64-bit unsigned integer equivalent of value.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(uint value)
			{
				throw;
			}

			//
			// Summary:
			//     Returns the specified 64-bit unsigned integer; no actual conversion is performed.
			//
			// Parameters:
			//   value:
			//     A 64-bit unsigned integer.
			//
			// Returns:
			//     Parameter value is returned unchanged.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(ulong value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified 16-bit unsigned integer to the equivalent
			//     64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A 16-bit unsigned integer.
			//
			// Returns:
			//     The 64-bit unsigned integer equivalent to the value of value.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(ushort value)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the value of the specified System.object* to a 64-bit unsigned integer
			//     using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     An System.object* that implements the System.IConvertible interface.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 64-bit unsigned integer equivalent to the value of value, or zero if value
			//     is null.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(object* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the specified System.string* representation of a number to an equivalent
			//     64-bit unsigned integer using the specified culture-specific formatting information.
			//
			// Parameters:
			//   value:
			//     A System.string* containing a number to convert.
			//
			//   provider:
			//     An System.IFormatProvider* interface implementation that supplies culture-specific
			//     formatting information.
			//
			// Returns:
			//     A 64-bit unsigned integer equivalent to the value of value.-or- Zero if value
			//     is null.
			//
			// Exceptions:
			//   System.FormatException:
			//     value does not consist of an optional sign followed by a sequence of digits
			//     (zero through nine).
			//
			//   System.OverflowException:
			//     value represents a number less than System.Int64.MinValue or greater than
			//     System.Int64.MaxValue.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(string* value, IFormatProvider* provider)
			{
				throw;
			}

			//
			// Summary:
			//     Converts the string* representation of a number in a specified base to an
			//     equivalent 64-bit unsigned integer.
			//
			// Parameters:
			//   value:
			//     A string* containing a number.
			//
			//   fromBase:
			//     The base of the number in value, which must be 2, 8, 10, or 16.
			//
			// Returns:
			//     A 64-bit unsigned integer equivalent to the number in value.-or- Zero if
			//     value is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     fromBase is not 2, 8, 10, or 16. -or-value, which represents a non-base 10
			//     unsigned number, is prefixed with a negative sign.
			//
			//   System.FormatException:
			//     value contains a character that is not a valid digit in the base specified
			//     by fromBase. The exception message indicates that there are no digits to
			//     convert if the first character in value is invalid; otherwise, the message
			//     indicates that value contains invalid trailing characters.
			//
			//   System.OverflowException:
			//     value, which represents a non-base 10 unsigned number, is prefixed with a
			//     negative sign.-or-The return value is less than System.UInt64.MinValue or
			//     larger than System.UInt64.MaxValue.
			//[CLSCompliant(false)]
			public: static ulong ToUInt64(string* value, int fromBase)
			{
				throw;
			}

		};
	}
}

#endif